/**
 * 数学公式渲染工具
 * 用于在页面上显示LaTeX数学公式
 */

import katex from 'katex'
import 'katex/dist/katex.min.css'

/**
 * 渲染HTML中的数学公式和图片
 * 将 $$...$$ 包裹的LaTeX公式转换为可显示的HTML
 * 将 ![](url) markdown图片转换为img标签
 * @param {string} htmlContent - 包含公式和图片的HTML内容
 * @returns {string} - 渲染后的HTML
 */
export function renderMathInHTML(htmlContent) {
  if (!htmlContent) return ''
  
  // 匹配 $$...$$ 格式的公式（块级公式）
  const blockFormula = /\$\$([^\$]+)\$\$/g
  // 匹配 $...$ 格式的公式（行内公式）
  const inlineFormula = /\$([^\$]+)\$/g
  // 匹配markdown图片 ![alt](url)
  const markdownImage = /!\[([^\]]*)\]\(([^)]+)\)/g
  
  try {
    let result = htmlContent
    
    // 先处理图片（避免与公式冲突）
    // 兼容markdown格式的图片
    result = result.replace(markdownImage, (match, alt, url) => {
      return `<img src="${url}" alt="${alt}" class="content-image" />`
    })
    
    // 处理已有的img标签，添加class（如果没有）
    result = result.replace(/<img([^>]*?)src="([^"]+)"([^>]*?)>/g, (match, before, src, after) => {
      // 如果已经有content-image或discussion-image class，就不重复添加
      if (match.includes('class="content-image"') || match.includes('class="discussion-image"')) {
        return match
      }
      return `<img${before}src="${src}"${after} class="content-image">`
    })
    
    // 处理块级公式
    result = result.replace(blockFormula, (match, latex) => {
      try {
        return `<span class="math-display">${katex.renderToString(latex.trim(), {
          throwOnError: false,
          displayMode: true
        })}</span>`
      } catch (error) {
        console.warn('公式渲染失败:', latex, error)
        return `<span class="math-error">公式错误: ${latex}</span>`
      }
    })
    
    // 处理行内公式
    result = result.replace(inlineFormula, (match, latex) => {
      try {
        return `<span class="math-inline">${katex.renderToString(latex.trim(), {
          throwOnError: false,
          displayMode: false
        })}</span>`
      } catch (error) {
        console.warn('公式渲染失败:', latex, error)
        return `<span class="math-error">${latex}</span>`
      }
    })
    
    return result
  } catch (error) {
    console.error('渲染内容失败:', error)
    return htmlContent
  }
}

/**
 * 在DOM元素中渲染数学公式
 * @param {HTMLElement} element - 目标DOM元素
 */
export function renderMathInElement(element) {
  if (!element) return
  
  const htmlContent = element.innerHTML
  element.innerHTML = renderMathInHTML(htmlContent)
}

/**
 * 判断文本中是否包含数学公式
 * @param {string} text - 文本内容
 * @returns {boolean}
 */
export function hasMathFormula(text) {
  if (!text) return false
  return /\$\$[^\$]+\$\$|\$[^\$]+\$/.test(text)
}

/**
 * 提取文本中的所有公式
 * @param {string} text - 文本内容
 * @returns {Array<string>} - 公式数组
 */
export function extractFormulas(text) {
  if (!text) return []
  
  const formulas = []
  const blockRegex = /\$\$([^\$]+)\$\$/g
  const inlineRegex = /\$([^\$]+)\$/g
  
  let match
  while ((match = blockRegex.exec(text)) !== null) {
    formulas.push(match[1].trim())
  }
  
  while ((match = inlineRegex.exec(text)) !== null) {
    formulas.push(match[1].trim())
  }
  
  return formulas
}

/**
 * 验证LaTeX公式语法
 * @param {string} latex - LaTeX公式
 * @returns {Object} - { valid: boolean, error: string }
 */
export function validateLatex(latex) {
  if (!latex) {
    return { valid: false, error: '公式不能为空' }
  }
  
  try {
    katex.renderToString(latex, { throwOnError: true })
    return { valid: true, error: null }
  } catch (error) {
    return { valid: false, error: error.message }
  }
}

